#ifndef RECURSO_H
#define	RECURSO_H

#ifdef	__cplusplus
extern "C" {
#endif    
    
    struct recurso {
        int alocados[3];  //processo que pediu recurso
        int existentes[3];  //recursos que a CPU total e quais sao        
        Processo *bloqueados_falta_recursos[4];
    };
    
    typedef struct recurso Recurso;       

    /**
    * Funcao responsavel por alocar vetor de recursos
    * @return ponteiro onde estao armazendados os recursos
    */
    Recurso* recurso_init();

    /**
    * Funcao responsavel por verificar
    * @param p
    * @return -2 Erro Fatal, -1 Recurso nao Disponivel, 0 Recurso Alocado com sucesso
    */
    int recurso_pedido(Processo *p);

    /**
    * Funcao coloca um processo que requisitou um recurso mais nao teve acesso a ele
    * @param processo
    * @return int
    */
    int recurso_bloqueado_por_falta(Processo *p, int pedido);

    /**
    * Funcao que verifica a ocorrencia de deadlock
    * @param processo 
    * @param pedido
    * @return void
    */
    void recurso_verifica_deadLock(Processo *p, int pedido);

    /**
    * Imprime o caminho de deadlock
    * @return void
    */
    void recurso_caminho();

    /**
    * Fucao que retorna recurso necessario.
    * @param entra um processo
    * @return elemento posicao ou se tiver vazio o vetor retorna -1
    */
    int recurso_recupera_elemeto_vetor(Processo* p);

    /**
    * Verifica recurso disponivel, e ja aloca.
    * - Se nao aloca e retorna -1.
    * @param pedido
    * @param r
    * @return 
    */
    int recurso_usar(int pedido);

    /**
    * Checa se existe existe no vetor alocado o recurso
    * @param pedido
    * @return se existir retorna a posica se nao existir recurso ja alocado retorna -1
    */
    int recurso_posicao_alocados(int pedido);

    /**
    * Checa se existe existe no vetor alocado o recurso
    * @param pedido
    * @return int retorna a posicao
    */
    int recurso_posicao_existente(int pedido);
    
    
    /**
    * Função libera recursos.
    * @param p
    */
    int recurso_libera(Processo *p, int pedido);
    
    /**
    * Função que decrementa o indicador dos recursos em Processo
    * @param p
    */
    void recurso_decrementa_indicador(Processo* p);
    
    /**
    * Função recupera Deadlock por meio da eliminação do processo para liberar seus recursos.
    * @param p, pedido
    */
    void recuperacao_elimina_processo(Processo *p, int pedido);
    
    /**
    * Função recupera Deadlock por meio da preempção do processo
    * @param p, pedido
    */
    void recuperacao_preempcao(Processo *p, int pedido);

    /**
    * Impressao de vetores
    */
    void recurso_imprime_vetor_alocados();

    void recurso_imprime_vetor_existentes();

    void recurso_imprime_vetor_bloqueados();
    
    int recurso_processo_alocados(Processo *p);
    
    int recurso_quero_liberar(Processo *p);
    
    void recurso_liberar_todos_recursos(Processo* p);

#ifdef	__cplusplus
}
#endif

#endif	/* RECURSO_H */

